home *** CD-ROM | disk | FTP | other *** search
/ TPUG - Toronto PET Users Group / TPUG Users Group CD / TPUG Users Group CD.iso / AMIGA / AMICUS / AMICUS01.ADF / C / fasterfp.c < prev    next >
C/C++ Source or Header  |  1985-11-15  |  23KB  |  795 lines
  1. /* how to use the ffp library, text and source */
  2.  
  3. #ifdef FOOIE
  4.  
  5. From: bobp@amiga.UUCP (Robert S. Pariseau)
  6. Subject: Amiga Floating Point
  7. Date: 1 Nov 85 04:58:43 GMT
  8.  
  9. Floating point support exists on the Amiga in several forms for several 
  10. purposes.  The floating point which is directly supported by expression 
  11. evaluation in the V1.0 release Lattice C for the Amiga is a 64 bit software 
  12. implementation of the IEEE format.  As such, it is *>SLOW<*.
  13.  
  14. The floating point in ABasiC is a 32 bit IEEE format running in a somewhat 
  15. simpler exception handling environment.
  16.  
  17. Motorola Fast Floating Point format is available (in 32 bits only) in two 
  18. standard libraries.  The fundamental math routines are in the library mathffp 
  19. which resides in the Writeable Control Store.  The corresponding 
  20. transcendental functions are in the library mathtrans which is disk-based 
  21. (i.e., it's found in the LIBS: directory and is brought into memory and 
  22. shared between programs as needed).
  23.  
  24. To access routines in these libraries you do an OpenLibrary() call and then 
  25. call the desired routine using one of the interface entrypoints defined in 
  26. amiga.lib.
  27.  
  28. Yes, we are working with Lattice to make the 32 bit IEEE format and the 32 
  29. bit Motorola format routines directly available from the language.
  30.  
  31. We do not expect to make the Amiga schematics public anytime soon.  There 
  32. will, however, be more info available about the timing and characteristics of 
  33. the expansion bus.  
  34.  
  35.  
  36. From bobp@amiga.UUCP (Robert S. Pariseau) Tue Nov  5 21:53:01 1985
  37. Path: gumby!uwvax!seismo!lll-crg!ucdavis!ucbvax!decvax!decwrl
  38.             !pyramid!amiga!bobp
  39. From: bobp@amiga.UUCP (Robert S. Pariseau)
  40. Date: 6 Nov 85 03:53:01 GMT
  41. Reply-To: bobp@snake.UUCP (Robert S. Pariseau)
  42. Organization: Commodore-Amiga Inc., 983 University Ave #D, Los Gatos CA 95030
  43.  
  44. TITLE:  LatFFP program SOURCE (LONG!)
  45.  
  46. The program below shows how to access the Motorola Fast Floating Point 
  47. libraries from V1.0 release Lattice C for the Amiga.  As you will see when 
  48. you run it, the performance improvement gained by using the FFP routines 
  49. (even in this kludgey fashion) is generally around a factor of 10!
  50.  
  51. Part of that improvement is just the difference in precision.  The Lattice 
  52. stuff provides a 64 bit software implementation of the IEEE format.  The FFP 
  53. stuff provides a 32 bit implementation of the Motorola format.
  54.  
  55. The variables used for FFP math are defined as ints.  You can't use FLOATs 
  56. because V1.0 Lattice C converts FLOAT to DOUBLE during expression evaluation 
  57. and when passing arguments.
  58.  
  59. ------------------------Program Notes:
  60.  
  61. The program will compile and link cleanly using the stuff on the standard 
  62. V1.0 Lattice C for Amiga disk.  The Make script in the examples directory 
  63. will do all the work for you.  Since my C disk is rather full, and since I 
  64. like the dramatic increase in speed, I usually do my work in ram disk as 
  65. follows:
  66.  
  67.   1> cd df1:                               [my C disk]
  68.   1> copy examples/Make to :               [more convenient in root]
  69.   
  70.   1> copy LatFFP.c to ram:
  71.   1> execute Make ram:LatFFP
  72.   1> copy ram:LatFFP to df1:
  73.  
  74. I've also added a "stack 20000" command in my startup script 
  75. (s/startup-sequence) to make sure I don't have to worry about stack overflows.
  76.  
  77. The program shows 3 bugs in the V1.0 stuff and includes one kludge. The bugs 
  78. and kludge are maked in the source.  
  79.  
  80. Bug (1): V1.0 Lattice C doesn't properly handle successive assignments of 
  81. constants.  Use expressions.  
  82.  
  83. Bug (2): V1.0 FFP doesn't correctly return a result from SPCmp().  Fake it 
  84. with subtraction and SPTst() or write your own compare for now.  
  85.  
  86. Bug (3): V1.0 FFP doesn't correctly return the cosine result from SPSincos(). 
  87.  Use SPCos() instead.
  88.  
  89. The kludge is the set of union definitions so that we can use the same 
  90. variables for related Lattice and FFP expressions and for the conversions in 
  91. and out of IEEE format.  Note that we use the Lattice IEEE based routines in 
  92. printf() to get our output.
  93.  
  94. Note however, that the conversion routines are in the RAM based MathTrans 
  95. library.  Therefore, if you only want to use the WCS based MathFFP library, 
  96. you are on your own for conversion.
  97.  
  98. ------------------------Program Source Follows:
  99. #endif FOOIE
  100.  
  101.  
  102. /***********************************************************************
  103.  *  LatFFP -- Program to show the use of Motorola Fast Floating Point
  104.  *            math libraries with V1.0 Lattice C for the Amiga in
  105.  *            comparison to the DOUBLE precision IEEE floating point
  106.  *            math which is built in to the C.  The FFP format is
  107.  *            a 32 bit format.
  108.  *
  109.  *  Larry Hildenbrand -- Nov. 4, 1985
  110.  *  Bob Pariseau      -- Nov. 4, 1985  (minor editorial corrections)
  111.  *
  112.  ***********************************************************************/
  113.  
  114. #include <exec/types.h>
  115. #include <math.h>
  116.  
  117.  
  118. /* ??? #define   E      2.718281828459045 */  /* V1.0 Lattice C BUG!  See */
  119. #define   PIME   0.423310826                  /* below.  PIME == PI - E.  */
  120.  
  121.  
  122. /****  MAY BE BROKEN OUT INTO SEPARATE #include FILE ****/
  123.  
  124. extern   int     SPFix();
  125. extern   int     SPFlt();
  126. extern   int     SPCmp();
  127. extern   int     SPTst();
  128. extern   int     SPAbs();
  129. extern   int     SPNeg();
  130. extern   int     SPAdd();
  131. extern   int     SPSub();
  132. extern   int     SPMul();
  133. extern   int     SPDiv();
  134.  
  135. extern   int     SPAtan();
  136. extern   int     SPSin();
  137. extern   int     SPCos();
  138. extern   int     SPTan();
  139. extern   int     SPSincos();
  140. extern   int     SPSinh();
  141. extern   int     SPCosh();
  142. extern   int     SPTanh();
  143. extern   int     SPExp();
  144. extern   int     SPLog();
  145. extern   int     SPPow();
  146. extern   int     SPSqrt();
  147. extern   int     SPTieee();
  148. extern   int     SPFieee();
  149.  
  150. /********************************************************/
  151.  
  152.  
  153. char st1[80] = "3.1415926535897";
  154. char st2[80] = "2.718281828459045";
  155.  
  156.  
  157. int MathBase;        /* Basic FFP lib pointer */
  158. int MathTransBase;   /* Transcendental FFP lib pointer */
  159.  
  160. int dots_good = 0;
  161.  
  162.  
  163. union kludge1        /* Can't use FLOAT directly for FFP stuff */
  164. {                    /* because V1.0 Lattice converts FLOAT to */
  165.   FLOAT num1;        /* DOUBLE in expressions and when passing */
  166.   int   i1;          /* parameters.                            */
  167. } k1;
  168.  
  169. union kludge2
  170. {
  171.   FLOAT num2;
  172.   int   i2;
  173. } k2;
  174.  
  175. union kludge3
  176. {
  177.   FLOAT num3;
  178.   int   i3;
  179. } k3;
  180.  
  181. union kludge4
  182. {
  183.   FLOAT num4;
  184.   int   i4;
  185. } k4;
  186.  
  187. union kludge5
  188. {
  189.   FLOAT num5;
  190.   int   i5;
  191. } k5;
  192.  
  193. union kludge6
  194. {
  195.   FLOAT num6;
  196.   int   i6;
  197. } k6;
  198.  
  199.  
  200.  
  201. show_dot() { if( ++dots_good == 1000) { dots_good = 0; printf(".");} }
  202.  
  203.  
  204.  
  205. show_result( num ) FLOAT num; { printf("\nResult = %f", num); }
  206.  
  207.  
  208.  
  209. show_result_ffp(in_val)   /* Convert to IEEE and display */
  210.   int in_val;
  211. {
  212.   union kludge_sr
  213.   {
  214.     FLOAT new_iv_f;
  215.     int   new_iv_i;
  216.   } k;
  217.  
  218.   k.new_iv_i = SPTieee(in_val);
  219.   show_result(k.new_iv_f);
  220. }
  221.  
  222.  
  223.  
  224.  
  225. main()                  /* Lattice/FFP test code */
  226. {
  227.    UWORD i;
  228.    int i3;
  229.  
  230.    printf("C-ROM & Shared RAM Library Test Facility for the Amiga-Lattice Basic/Trans Math Libraries");
  231.  
  232. /*****************************************/
  233. /*****************************************/
  234. /***                                   ***/
  235. /***  OPEN ROM AND RAM FFP LIBRARIES   ***/
  236. /***                                   ***/
  237. /*****************************************/
  238. /*****************************************/
  239.  
  240.    if((MathBase = OpenLibrary("mathffp.library", 0)) < 1 ) {
  241.        printf("\n\n*** ERROR ***  Can't open mathffp.library: vector = %lx\n", MathBase);
  242.        exit();
  243.    }
  244.    else {
  245.        printf("\n\nSuccessfully opened mathffp.library: vector = %lx\n", MathBase);
  246.    }
  247.  
  248.    if((MathTransBase = OpenLibrary("mathtrans.library", 0)) < 1 ) {
  249.        printf("\n\n*** ERROR ***  Can't open mathtrans.library: vector = %lx\n", MathTransBase);
  250.        CloseLibrary(MathBase);
  251.        exit();
  252.    }
  253.    else {
  254.        printf("\n\nSuccessfully opened mathtrans.library: vector = %lx\n", MathTransBase);
  255.    }
  256.  
  257.  
  258. /*****************************************/
  259. /*****************************************/
  260. /***                                   ***/
  261. /***  COMPILER & FFP S.P. ADDITION     ***/
  262. /***                                   ***/
  263. /*****************************************/
  264. /*****************************************/
  265.  
  266.    k1.num1 = PI;                  /* V1.0 Lattice C BUG!  Can't have two  */
  267.    k2.num2 = k1.num1 - PIME;      /* constant assignments in a row.  Fake */
  268.                                   /* it by making the second be an        */
  269.                                   /* expression!                          */
  270.  
  271.  
  272.    printf("\n\n50,000 additions of %s to %s (Compiler Interface)\n", st1, st2);
  273.    for( dots_good = 0, i= 1; i < 50000; i++ )
  274.    {
  275.       k3.num3 = k1.num1 + k2.num2;
  276.       show_dot();
  277.    }
  278.    show_result( k3.num3 );
  279.  
  280.  
  281.    k1.i1 = SPFieee(k1.i1);
  282.    k2.i2 = SPFieee(k2.i2);
  283.  
  284.    printf("\n\n50,000 additions of %s to %s (Function Interface)\n", st1, st2 );
  285.    for( dots_good = 0, i= 1; i < 50000; i++ )
  286.    {
  287.       k3.i3 = SPAdd(k2.i2, k1.i1);
  288.       show_dot();
  289.    }
  290.    show_result_ffp( k3.i3 );
  291.  
  292.  
  293. /*****************************************/
  294. /*****************************************/
  295. /***                                   ***/
  296. /***  COMPILER & FFP S.P. SUBTRACTION  ***/
  297. /***                                   ***/
  298. /*****************************************/
  299. /*****************************************/
  300.  
  301.    k1.num1 = PI;
  302.    k2.num2 = k1.num1 - PIME;
  303.  
  304.    printf("\n\n50,000 subtractions of %s from %s (Compiler Interface)\n", st1, st2 );
  305.    for( dots_good = 0, i= 1; i < 50000; i++ )
  306.    {
  307.       k3.num3 = k2.num2 - k1.num1;
  308.       show_dot();
  309.    }
  310.    show_result( k3.num3 );
  311.  
  312.  
  313.    k1.i1 = SPFieee(k1.i1);
  314.    k2.i2 = SPFieee(k2.i2);
  315.  
  316.    printf("\n\n50,000 subtractions of %s from %s (Function Interface)\n", st1, st2 );
  317.    for( dots_good = 0, i= 1; i < 50000; i++ )
  318.    {
  319.       k3.i3 = SPSub(k1.i1, k2.i2);
  320.       show_dot();
  321.    }
  322.    show_result_ffp( k3.i3 );
  323.  
  324.    
  325. /*****************************************/
  326. /*****************************************/
  327. /***                                   ***/
  328. /***  COMPILER & FFP S.P. MULTIPLYS    ***/
  329. /***                                   ***/
  330. /*****************************************/
  331. /*****************************************/
  332.  
  333.    k1.num1 = PI;
  334.    k2.num2 = k1.num1 - PIME;
  335.  
  336.    printf("\n\n50,000 multiplies of %s by %s (Compiler Interface)\n", st1, st2 );
  337.    for( dots_good = 0, i= 1; i < 50000; i++ )
  338.    {
  339.       k3.num3 = k1.num1 * k2.num2;
  340.       show_dot();
  341.    }
  342.    show_result( k3.num3 );
  343.    
  344.  
  345.    k1.i1 = SPFieee(k1.i1);
  346.    k2.i2 = SPFieee(k2.i2);
  347.  
  348.    printf("\n\n50,000 multiplies of %s by %s (Function Interface)\n", st1, st2 );
  349.    for( dots_good = 0, i= 1; i < 50000; i++ )
  350.    {
  351.       k3.i3 = SPMul(k2.i2, k1.i1);
  352.       show_dot();
  353.    }
  354.    show_result_ffp( k3.i3 );
  355.  
  356.  
  357. /*****************************************/
  358. /*****************************************/
  359. /***                                   ***/
  360. /***  COMPILER & FFP S.P. DIVISION     ***/
  361. /***                                   ***/
  362. /*****************************************/
  363. /*****************************************/
  364.  
  365.    k1.num1 = PI;
  366.    k2.num2 = k1.num1 - PIME;
  367.  
  368.    printf("\n\n50,000 divides of %s by %s (Compiler Interface)\n", st1, st2 );
  369.    for( dots_good = 0, i= 1; i < 50000; i++ )
  370.    {
  371.       k3.num3 = k1.num1 / k2.num2;
  372.       show_dot();
  373.    }
  374.    show_result( k3.num3 );
  375.  
  376.  
  377.    k1.i1 = SPFieee(k1.i1);
  378.    k2.i2 = SPFieee(k2.i2);
  379.  
  380.    printf("\n\n50,000 divides of %s by %s (Function Interface)\n", st1, st2 );
  381.    for( dots_good = 0, i= 1; i < 50000; i++ )
  382.    {
  383.       k3.i3 = SPDiv(k2.i2, k1.i1);
  384.       show_dot();
  385.    }
  386.    show_result_ffp( k3.i3 );
  387.  
  388.  
  389. /*****************************************/
  390. /*****************************************/
  391. /***                                   ***/
  392. /***  COMPILER & FFP S.P. TRUNCATION   ***/
  393. /***                                   ***/
  394. /*****************************************/
  395. /*****************************************/
  396.  
  397.    k1.num1 = PI;
  398.    k2.num2 = k1.num1 - PIME;
  399.  
  400.    printf("\n\n50,000 fixes of %s (Compiler Interface)\n", st1 );
  401.    for( dots_good = 0, i= 1; i < 50000; i++ )
  402.    {
  403.       i3 = (int) k1.num1;
  404.       if( ++dots_good == 1000) { dots_good = 0; printf(".");}
  405.    }
  406.    printf("\nResult = %d", i3 );
  407.  
  408.  
  409.    k1.i1 = SPFieee(k1.i1);
  410.    k2.i2 = SPFieee(k2.i2);
  411.  
  412.    printf("\n\n50,000 fixes of %s (Function Interface)\n", st1 );
  413.    for( dots_good = 0, i= 1; i < 50000; i++ )
  414.    {
  415.       i3 = SPFix(k1.i1);
  416.       if( ++dots_good == 1000) { dots_good = 0; printf(".");}
  417.    }
  418.    printf("\nResult = %d", i3);
  419.  
  420.  
  421. /*****************************************/
  422. /*****************************************/
  423. /***                                   ***/
  424. /***  COMPILER & FFP S.P. FLOATATION   ***/
  425. /***                                   ***/
  426. /*****************************************/
  427. /*****************************************/
  428.  
  429.    i3 = 5;
  430.  
  431.    printf("\n\n50,000 floats of %d (Compiler Interface)\n", i3 );
  432.    for( dots_good = 0, i= 1; i < 50000; i++ )
  433.    {
  434.        k4.num4 = (FLOAT) i3;
  435.       show_dot();
  436.    }
  437.    show_result( k4.num4 );
  438.  
  439.  
  440.    printf("\n\n50,000 floats of %d (Function Interface)\n", i3 );
  441.    for( dots_good = 0, i= 1; i < 50000; i++ )
  442.    {
  443.        k4.i4 = SPFlt(i3);
  444.       show_dot();
  445.    }
  446.    show_result_ffp( k4.i4 );
  447.  
  448.  
  449. /*****************************************/
  450. /*****************************************/
  451. /***                                   ***/
  452. /***  COMPILER & FFP S.P. NEGATION     ***/
  453. /***                                   ***/
  454. /*****************************************/
  455. /*****************************************/
  456.  
  457.    k1.num1 = PI;
  458.    k2.num2 = k1.num1 - PIME;
  459.  
  460.    printf("\n\n50,000 negates of %s (Compiler Interface)\n", st2 );
  461.    for( dots_good = 0, i= 1; i < 50000; i++ )
  462.    {
  463.       k4.num4 = -k2.num2;
  464.       show_dot();
  465.    }
  466.    show_result( k4.num4 );
  467.  
  468.  
  469.    k1.i1 = SPFieee(k1.i1);
  470.    k2.i2 = SPFieee(k2.i2);
  471.  
  472.    printf("\n\n50,000 negates of %s (Function Interface)\n", st2 );
  473.    for( dots_good = 0, i= 1; i < 50000; i++ )
  474.    {
  475.       k4.i4 = SPNeg(k2.i2);
  476.       show_dot();
  477.    }
  478.    show_result_ffp( k4.i4 );
  479.  
  480.  
  481. /*****************************************/
  482. /*****************************************/
  483. /***                                   ***/
  484. /***  COMPILER & FFP S.P. ABSOLUTE VAL ***/
  485. /***                                   ***/
  486. /*****************************************/
  487. /*****************************************/
  488.  
  489.    k1.num1 = PI;
  490.    k4.num4 = PIME - k1.num1;
  491.  
  492.    printf("\n\n50,000 absolute values of %f (Compiler Interface)\n", k4.num4 );
  493.    for( dots_good = 0, i= 1; i < 50000; i++ )
  494.    {
  495.       k5.num5 = fabs(k4.num4);
  496.       show_dot();
  497.    }
  498.    show_result( k5.num5 );
  499.  
  500.  
  501.    printf("\n\n50,000 absolute values of %f (Function Interface)\n", k4.num4 );
  502.    k4.i4 = SPFieee(k4.i4);
  503.    for( dots_good = 0, i= 1; i < 50000; i++ )
  504.    {
  505.       k5.i5 = SPAbs(k4.i4);
  506.       show_dot();
  507.    }
  508.    show_result_ffp( k5.i5 );
  509.  
  510.  
  511.    printf("\n\n*** HIT RETURN TO CONTINUE ***");   getch();
  512.  
  513.  
  514. /*****************************************/
  515. /*****************************************/
  516. /***                                   ***/
  517. /***  COMPILER & FFP S.P. COMPARE      ***/
  518. /***                                   ***/
  519. /*****************************************/
  520. /*****************************************/
  521.  
  522.    k1.num1 = PI;
  523.    k2.num2 = k1.num1 - PIME;
  524.  
  525.    if (k2.num2 >= k1.num1)
  526.       printf("\n\n%f is greater than or equal to %f (Compiler Interface)\n", k2.num2, k1.num1);
  527.    else
  528.       printf("\n\n%f is less than %f (Compiler Interface)\n", k2.num2, k1.num1);
  529.  
  530.  
  531.    k1.i1 = SPFieee(k1.i1);
  532.    k2.i2 = SPFieee(k2.i2);
  533.  
  534.    printf("\n*** SPCmp(k2.i2, k1.i1) returned %d ***", SPCmp(k2.i2, k1.i1));
  535.  
  536.  
  537.    if (SPCmp(k2.i2, k1.i1))     /* V1.0 FFP Bug.  SPCmp() broken. */
  538.  
  539.    {  k1.num1 = PI;
  540.       k2.num2 = k1.num1 - PIME;
  541.       printf("\n\n%f is greater than or equal to %f (Function Interface)\n", k2.num2, k1.num1);
  542.    }
  543.    else
  544.    {  k1.num1 = PI;
  545.       k2.num2 = k1.num1 - PIME;
  546.       printf("\n\n%f is less than %f (Function Interface)\n", k2.num2, k1.num1);
  547.    }
  548.  
  549.  
  550.    if (k1.num1 >= k2.num2)
  551.       printf("\n\n%f is greater than or equal to %f (Compiler Interface)\n", k1.num1, k2.num2);
  552.    else
  553.       printf("\n\n%f is less than %f (Compiler Interface)\n", k1.num1, k2.num2);
  554.  
  555.  
  556.    k1.i1 = SPFieee(k1.i1);
  557.    k2.i2 = SPFieee(k2.i2);
  558.  
  559.    if (SPCmp(k1.i1, k2.i2))
  560.    {  k1.num1 = PI;
  561.       k2.num2 = k1.num1 - PIME;
  562.       printf("\n\n%f is greater than or equal to %f (Function Interface)\n", k1.num1, k2.num2);
  563.    }
  564.    else
  565.    {  k1.num1 = PI;
  566.       k2.num2 = k1.num1 - PIME;
  567.       printf("\n\n%f is less than %f (Function Interface)\n", k1.num1, k2.num2);
  568.    }
  569.  
  570.  
  571. /*****************************************/
  572. /*****************************************/
  573. /***                                   ***/
  574. /***  COMPILER & FFP S.P. TEST         ***/
  575. /***                                   ***/
  576. /*****************************************/
  577. /*****************************************/
  578.  
  579.    if (k2.num2)
  580.       printf("\n\n%f is not equal to 0.0 (Compiler Interface)\n", k2.num2);
  581.    else
  582.       printf("\n\n%f is equal to 0.0 (Compiler Interface)\n", k2.num2);
  583.  
  584.  
  585.    k2.i2 = SPFieee(k2.i2);
  586.  
  587.    if (SPTst(k2.i2))
  588.    {  k1.num1 = PI;
  589.       k2.num2 = k1.num1 - PIME;
  590.       printf("\n\n%f is not equal to 0.0 (Function Interface)\n", k2.num2);
  591.    }
  592.    else
  593.    {  k1.num1 = PI;
  594.       k2.num2 = k1.num1 - PIME;
  595.       printf("\n\n%f is equal to 0.0 (Function Interface)\n", k2.num2);
  596.    }
  597.  
  598.  
  599.    k2.num2 = 0.0;
  600.  
  601.    if (k2.num2)
  602.       printf("\n\n%f is not equal to 0.0 (Compiler Interface)\n", k2.num2);
  603.    else
  604.       printf("\n\n%f is equal to 0.0 (Compiler Interface)\n", k2.num2);
  605.  
  606.  
  607.    k2.i2 = SPFieee(k2.i2);
  608.  
  609.    if (SPTst(k2.i2))
  610.    {  k2.num2 = 0.0;
  611.       printf("\n\n%f is not equal to 0.0 (Function Interface)\n", k2.i2);
  612.    }
  613.    else
  614.    {  k2.num2 = 0.0;
  615.       printf("\n\n%f is equal to 0.0 (Function Interface)\n", k2.i2);
  616.    }
  617.  
  618.  
  619. /*****************************************/
  620. /*****************************************/
  621. /***                                   ***/
  622. /***  FFP S.P. SQUARE ROOT             ***/
  623. /***                                   ***/
  624. /*****************************************/
  625. /*****************************************/
  626.  
  627.    k1.num1 = PI;
  628.    k2.num2 = k1.num1 - PIME;
  629.  
  630.    printf("\n\n50,000 square roots of %f\n", k2.num2);
  631.    k1.i1 = SPFieee(k1.i1);
  632.    k2.i2 = SPFieee(k2.i2);
  633.    for( dots_good = 0, i= 1; i < 50000; i++ )
  634.    {
  635.       k3.i3 = SPSqrt( k2.i2 );
  636.       show_dot();
  637.    }
  638.    show_result_ffp( k3.i3 );
  639.  
  640.  
  641. /*****************************************/
  642. /*****************************************/
  643. /***                                   ***/
  644. /***  FFP S.P. NATURAL LOGARITHM       ***/
  645. /***                                   ***/
  646. /*****************************************/
  647. /*****************************************/
  648.  
  649.    printf("\n\n40,000 logarithms of %s\n", st1 );
  650.    for( dots_good = 0, i= 1; i < 40000; i++ )
  651.    {
  652.       k3.i3 = SPLog( k1.i1 );
  653.       show_dot();
  654.    }
  655.    show_result_ffp( k3.i3 );
  656.  
  657.  
  658. /*****************************************/
  659. /*****************************************/
  660. /***                                   ***/
  661. /***  FFP S.P. EXPONENT (BASE e)       ***/
  662. /***                                   ***/
  663. /*****************************************/
  664. /*****************************************/
  665.  
  666.    printf("\n\n40,000 exponents of %s\n", st1 );
  667.    for( dots_good = 0, i= 1; i < 40000; i++ )
  668.    {
  669.       k3.i3 = SPExp( k1.i1 );
  670.       show_dot();
  671.    }
  672.    show_result_ffp( k3.i3 );
  673.  
  674.  
  675. /*****************************************/
  676. /*****************************************/
  677. /***                                   ***/
  678. /***  FFP S.P. SINE, COSINE & TANGENT  ***/
  679. /***                                   ***/
  680. /*****************************************/
  681. /*****************************************/
  682.  
  683.    k1.num1 = PI;
  684.    k2.num2 = k1.num1 - PIME;
  685.    k1.num1 = k1.num1 / 6.0;
  686.    k1.i1 = SPFieee(k1.i1);
  687.    k2.i2 = SPFieee(k2.i2);
  688.  
  689.    printf("\n\n20,000 sines, cosines and tangents of %s / 6 radians\n", st1 );
  690.    for( dots_good = 0, i= 1; i < 20000; i++ )
  691.    {
  692.       k2.i2 = SPSin(k1.i1);
  693.       k3.i3 = SPCos(k1.i1);
  694.       k4.i4 = SPTan(k1.i1);
  695.       k5.i5 = SPSincos(&k6.i6, k1.i1);  /* V1.0 FFP BUG!  Cosine return  */
  696.                                         /* value (k6.i6) of SPSincos is  */
  697.                                         /* broken.  Function result      */
  698.                                         /* (sine -- k5.i5) is OK.        */
  699.  
  700.       show_dot();
  701.    }
  702.    show_result_ffp( k2.i2 );   show_result_ffp( k3.i3 );
  703.    show_result_ffp( k4.i4 );
  704.    show_result_ffp( k5.i5 );   show_result_ffp( k6.i6 );
  705.  
  706.  
  707. /*****************************************/
  708. /*****************************************/
  709. /***                                   ***/
  710. /***  FFP S.P. ARCTANGENT              ***/
  711. /***                                   ***/
  712. /*****************************************/
  713. /*****************************************/
  714.  
  715.    printf("\n\n20,000 arctangents of the tangent of %s / 6 radians\n", st1 );
  716.    for( dots_good = 0, i= 1; i < 20000; i++ )
  717.    {
  718.       k2.i2 = SPAtan(k4.i4);
  719.       show_dot();
  720.    }
  721.    show_result_ffp( k2.i2 );
  722.  
  723.  
  724. /***************************************************/
  725. /***************************************************/
  726. /***                                             ***/
  727. /***  FFP S.P. HYPERBOLIC SINE, COSINE & TANGENT ***/
  728. /***                                             ***/
  729. /***************************************************/
  730. /***************************************************/
  731.  
  732.    k1.num1 = PI;
  733.    k2.num2 = k1.num1 - PIME;
  734.    k1.i1 = SPFieee(k1.i1);
  735.    k2.i2 = SPFieee(k2.i2);
  736.  
  737.    printf("\n\n20,000 hyperbolic sines, cosines and tangents of %s radians\n", st1 );
  738.    for( dots_good = 0, i= 1; i < 20000; i++ )
  739.    {
  740.       k2.i2 = SPSinh( k1.i1 );
  741.       k3.i3 = SPCosh( k1.i1 );
  742.       k4.i4 = SPTanh( k1.i1 );
  743.       show_dot();
  744.    }
  745.    show_result_ffp( k2.i2 );   show_result_ffp( k3.i3 );   show_result_ffp( k4.i4 );
  746.  
  747.  
  748. /*****************************************/
  749. /*****************************************/
  750. /***                                   ***/
  751. /***  FFP S.P. POWER FUNCTION          ***/
  752. /***                                   ***/
  753. /*****************************************/
  754. /*****************************************/
  755.  
  756.    k1.num1 = PI;
  757.    k2.num2 = k1.num1 - PIME;
  758.    k1.i1 = SPFieee(k1.i1);
  759.    k2.i2 = SPFieee(k2.i2);
  760.  
  761.    printf("\n\n10,000 %s raised to the %s power\n", st1, st2 );
  762.    for( dots_good = 0, i= 1; i < 10000; i++ )
  763.    {
  764.       k3.i3 = SPPow( k2.i2, k1.i1 );
  765.       show_dot();
  766.    }
  767.    show_result_ffp( k3.i3 );
  768.  
  769.  
  770. /*****************************************/
  771. /*****************************************/
  772. /***                                   ***/
  773. /***  CLOSE ROM AND RAM FFP LIBRARIES  ***/
  774. /***                                   ***/
  775. /*****************************************/
  776. /*****************************************/
  777.  
  778.    RemLibrary(MathTransBase);    /* Mark lib for Expunge() from RAM upon  */
  779.                                  /* CloseLibrary() by last opener.  Else  */
  780.                                  /* lib stays in RAM for others to use    */
  781.                                  /* quickly (no need to go to disk) until */
  782.                                  /* AllocMem() finds it needs the memory  */
  783.                                  /* for some other purpose.               */
  784.   
  785.    CloseLibrary(MathTransBase);  /* Close transcendental math RAM library */
  786.  
  787.  
  788.  
  789.    CloseLibrary(MathBase);       /* Close basic math ROM library */
  790.  
  791.  
  792.    printf("\n\nEnd C-ROM & Shared RAM Library Test (LATTICE) \n");
  793. }
  794.  
  795.